/**
 * 脑波频域数据结构
 * 
 * 该文件定义了脑波频域的数据结构和颜色配置
 * 包含五个主要频域：Delta、Theta、Alpha、Beta、Gamma
 * 每个频域都有对应的颜色和比例值
 * 
 * 原理：
 * - 脑波信号通过FFT变换分解为不同频域
 * - 每个频域占据总能量的一定比例
 * - 通过颜色区分不同频域，便于可视化分析
 */

package com.example.brain_wave.ui.components

import androidx.compose.ui.graphics.Color

/**
 * 脑波频域枚举
 * 定义五个主要的脑波频域及其特征
 */
enum class BrainWaveFrequency(
    val displayName: String,
    val color: Color,
    val frequencyRange: String
) {
    DELTA("Delta", Color(0xFF1E88E5), "0.5-4 Hz"),      // 蓝色 - 深度睡眠
    THETA("Theta", Color(0xFF43A047), "4-8 Hz"),        // 绿色 - 浅睡眠/冥想
    ALPHA("Alpha", Color(0xFFFDD835), "8-13 Hz"),       // 黄色 - 放松状态
    BETA("Beta", Color(0xFFFF8F00), "13-30 Hz"),        // 橙色 - 清醒/专注
    GAMMA("Gamma", Color(0xFFD32F2F), "30-100 Hz")      // 红色 - 高度专注
}

/**
 * 用户状态枚举
 * 定义用户的睡眠和清醒状态
 * 
 * 睡眠阶段说明:
 * - 清醒状态 (Wake/awake)
 * - 困倦状态 (N1/drowsy) 
 * - 浅睡眠 (N2/light_sleep)
 * - 深度睡眠 (N3/deep_sleep)
 * - 快速眼动睡眠 (REM/rem_sleep)
 */
enum class UserState(
    val displayName: String,
    val color: Color,
    val value: Int
) {
    AWAKE("清醒", Color(0xFF4CAF50), 4),        // 绿色 - 清醒状态
    DROWSY("困倦", Color(0xFFFFEB3B), 3),       // 黄色 - 困倦状态 (N1)
    LIGHT_SLEEP("浅睡", Color(0xFFFF9800), 2), // 橙色 - 浅睡眠 (N2)
    DEEP_SLEEP("深睡", Color(0xFF9C27B0), 1),  // 紫色 - 深度睡眠 (N3)
    REM_SLEEP("眼动", Color(0xFF2196F3), 0);   // 蓝色 - 快速眼动睡眠 (REM)
    
    companion object {
        /**
         * 从服务端返回的睡眠阶段字符串转换为UserState
         * 服务端分析结果优先，不再进行客户端推断
         */
        fun fromServerResponse(sleepStage: String?): UserState {
            return when (sleepStage?.lowercase()) {
                "awake", "wake" -> AWAKE
                "drowsy", "n1" -> DROWSY
                "light_sleep", "n2" -> LIGHT_SLEEP
                "deep_sleep", "n3" -> DEEP_SLEEP
                "rem_sleep", "rem" -> REM_SLEEP
                else -> LIGHT_SLEEP // 默认返回浅睡眠状态
            }
        }
    }
}

/**
 * 脑波频域数据点
 * 表示从服务端分析结果获取的脑波数据，用于UI渲染
 * 
 * 注意：此数据结构只包含UI渲染所需的基本字段
 * 所有分析和状态判断都由服务端完成
 */
data class BrainWaveDataPoint(
    val timestamp: Long,                    // 时间戳（毫秒）
    val deltaRatio: Float,                  // Delta波比例 (0.0-1.0) - 从服务端获取
    val thetaRatio: Float,                  // Theta波比例 (0.0-1.0) - 从服务端获取
    val alphaRatio: Float,                  // Alpha波比例 (0.0-1.0) - 从服务端获取
    val betaRatio: Float,                   // Beta波比例 (0.0-1.0) - 从服务端获取
    val gammaRatio: Float,                  // Gamma波比例 (0.0-1.0) - 从服务端获取
    val signalQuality: Float = 1.0f,        // 信号质量 (0.0-1.0) - 从服务端获取
    val userState: UserState = UserState.LIGHT_SLEEP  // 用户状态 - 从服务端获取，默认浅睡眠
) {
    /**
     * 获取指定频域的比例值
     */
    fun getRatioForFrequency(frequency: BrainWaveFrequency): Float {
        return when (frequency) {
            BrainWaveFrequency.DELTA -> deltaRatio
            BrainWaveFrequency.THETA -> thetaRatio
            BrainWaveFrequency.ALPHA -> alphaRatio
            BrainWaveFrequency.BETA -> betaRatio
            BrainWaveFrequency.GAMMA -> gammaRatio
        }
    }
    
    /**
     * 验证数据有效性（所有比例之和应该接近1.0）
     */
    fun isValid(): Boolean {
        val sum = deltaRatio + thetaRatio + alphaRatio + betaRatio + gammaRatio
        return sum in 0.95f..1.05f // 允许5%的误差
    }
}

/**
 * 泳道图配置
 * 定义泳道图的显示参数
 */
data class SwimLaneChartConfig(
    val timeWindowMs: Long = 30000L,        // 时间窗口（30秒）
    val maxDataPoints: Int = 300,           // 最大数据点数
    val displayTimeWindowSeconds: Int = 30, // 显示时间窗口（秒）
    val backgroundColor: Color = Color(0xFF1A1A1A),  // 背景色（深色）
    val gridColor: Color = Color(0xFF333333),        // 网格线颜色
    val textColor: Color = Color(0xFFFFFFFF),        // 文字颜色
    val showGrid: Boolean = true,           // 是否显示网格
    val showLabels: Boolean = true,         // 是否显示标签
    val animationDurationMs: Int = 300      // 动画持续时间
) {
    /**
     * 获取显示时间窗口的毫秒数
     */
    fun getDisplayTimeWindowMs(): Long = displayTimeWindowSeconds * 1000L
    
    /**
     * 预定义的时间窗口选项
     */
    companion object {
        const val ALL_DATA_WINDOW = -1 // 特殊值表示显示所有数据
        
        val TIME_WINDOW_OPTIONS = listOf(
            15 to "15秒",
            30 to "30秒", 
            60 to "1分钟",
            ALL_DATA_WINDOW to "全部"
        )
    }
}

/**
 * 生成模拟的脑波数据
 * 用于测试和演示，模拟NeuroSky设备的真实数据格式
 */
/**
 * 脑波数据生成器
 * 生成模拟的NeuroSky设备原始数据，不进行任何客户端分析
 */
object BrainWaveDataGenerator {
    
    /**
     * 生成单个NeuroSky原始数据点，模拟设备直接输出的数据
     * 不包含任何客户端计算的状态或比例，这些将由服务端分析
     */
    fun generateRawNeuroSkyData(timestamp: Long = System.currentTimeMillis()): NeuroSkyRawDataPoint {
        // 模拟NeuroSky 8个频段功率数据（μV²）
        // 这些是设备直接输出的24位功率值，不是比例
        // 根据NeuroPy3.py的解析逻辑：val0*65536+val1*256+int(payload[i],16)
        val delta = kotlin.random.Random.nextInt(1000, 50000)      // Delta波功率值
        val theta = kotlin.random.Random.nextInt(800, 40000)       // Theta波功率值
        val lowAlpha = kotlin.random.Random.nextInt(500, 30000)    // 低Alpha波功率值
        val highAlpha = kotlin.random.Random.nextInt(600, 25000)   // 高Alpha波功率值
        val lowBeta = kotlin.random.Random.nextInt(400, 35000)     // 低Beta波功率值
        val highBeta = kotlin.random.Random.nextInt(300, 30000)    // 高Beta波功率值
        val lowGamma = kotlin.random.Random.nextInt(200, 15000)    // 低Gamma波功率值
        val midGamma = kotlin.random.Random.nextInt(100, 8000)     // 中Gamma波功率值
        
        // 生成512Hz原始EEG数据（1秒钟的数据）
        val rawValues = generateRawEEGData()
        
        // 生成NeuroSky算法输出
        val (attention, meditation) = generateNeuroSkyMetrics()
        
        // 生成信号质量指标
        val (poorSignal, blinkStrength) = generateSignalQuality()
        
        return NeuroSkyRawDataPoint(
            timestamp = timestamp,
            rawValues = rawValues,
            delta = delta,
            theta = theta,
            lowAlpha = lowAlpha,
            highAlpha = highAlpha,
            lowBeta = lowBeta,
            highBeta = highBeta,
            lowGamma = lowGamma,
            midGamma = midGamma,
            attention = attention,
            meditation = meditation,
            poorSignal = poorSignal,
            blinkStrength = blinkStrength
        )
    }
    
    /**
     * 生成512Hz原始EEG数据（1秒钟的数据）
     * 模拟NeuroSky设备的原始数据格式
     * 根据NeuroPy3.py的实现，NeuroSky使用16位有符号整数
     */
    fun generateRawEEGData(): List<Int> {
        return (1..512).map { 
            // 模拟16位有符号整数范围 (-32768 到 32767)
            // 这与NeuroSky设备的真实数据格式一致
            kotlin.random.Random.nextInt(-32768, 32768)
        }
    }
    
    /**
     * 生成NeuroSky算法输出
     */
    fun generateNeuroSkyMetrics(): Pair<Int, Int> {
        // attention和meditation值 (0-100)
        val attention = kotlin.random.Random.nextInt(20, 80)
        val meditation = kotlin.random.Random.nextInt(20, 80)
        return Pair(attention, meditation)
    }
    
    /**
     * 生成信号质量指标
     */
    fun generateSignalQuality(): Pair<Int, Int> {
        // poorSignal (0-200, 0最好), blinkStrength (0-255)
        val poorSignal = kotlin.random.Random.nextInt(0, 50) // 模拟较好的信号质量
        val blinkStrength = kotlin.random.Random.nextInt(0, 20) // 偶尔的眨眼
        return Pair(poorSignal, blinkStrength)
    }
    
    /**
     * 生成单个BrainWaveDataPoint用于测试和演示
     * 注意：实际应用中，这些数据应该来自服务端分析结果
     * 为了测试UI显示，生成模拟的频域比例和用户状态数据
     */
    fun generateRandomDataPoint(timestamp: Long = System.currentTimeMillis()): BrainWaveDataPoint {
        // 生成随机的频域比例，确保总和为1.0
        val delta = kotlin.random.Random.nextFloat() * 0.4f + 0.1f  // 0.1-0.5
        val theta = kotlin.random.Random.nextFloat() * 0.3f + 0.1f  // 0.1-0.4
        val alpha = kotlin.random.Random.nextFloat() * 0.3f + 0.1f  // 0.1-0.4
        val beta = kotlin.random.Random.nextFloat() * 0.25f + 0.1f  // 0.1-0.35
        val gamma = kotlin.random.Random.nextFloat() * 0.15f + 0.05f // 0.05-0.2
        
        // 归一化，确保总和为1.0
        val total = delta + theta + alpha + beta + gamma
        val normalizedDelta = delta / total
        val normalizedTheta = theta / total
        val normalizedAlpha = alpha / total
        val normalizedBeta = beta / total
        val normalizedGamma = gamma / total
        
        // 根据频域比例推断用户状态（模拟服务端分析逻辑）
        // 平衡各种状态的生成概率
        val userState = when {
            normalizedDelta > 0.4f -> UserState.DEEP_SLEEP  // Delta波占主导 -> 深睡眠
            normalizedTheta > 0.35f -> UserState.LIGHT_SLEEP // Theta波占主导 -> 浅睡眠
            normalizedAlpha > 0.35f -> UserState.DROWSY      // Alpha波占主导 -> 困倦
            normalizedBeta > 0.3f -> UserState.AWAKE         // Beta波占主导 -> 清醒
            normalizedGamma > 0.15f -> UserState.REM_SLEEP   // Gamma波较高 -> REM睡眠
            else -> {
                // 随机分配，确保各状态都有机会出现
                val states = listOf(
                    UserState.DEEP_SLEEP, UserState.LIGHT_SLEEP, UserState.REM_SLEEP,
                    UserState.DROWSY, UserState.AWAKE
                )
                states.random()
            }
        }
        
        return BrainWaveDataPoint(
            timestamp = timestamp,
            deltaRatio = normalizedDelta,
            thetaRatio = normalizedTheta,
            alphaRatio = normalizedAlpha,
            betaRatio = normalizedBeta,
            gammaRatio = normalizedGamma,
            signalQuality = kotlin.random.Random.nextFloat() * 0.3f + 0.7f, // 0.7-1.0 高质量信号
            userState = userState
        )
    }

    /**
     * 生成一批NeuroSky原始数据样本
     */
    fun generateRawSampleData(
        count: Int = 100,
        intervalMs: Long = 100L
    ): List<NeuroSkyRawDataPoint> {
        val startTime = System.currentTimeMillis()
        return (0 until count).map { index ->
            generateRawNeuroSkyData(startTime + index * intervalMs)
        }
    }
}

/**
 * NeuroSky原始数据点
 * 表示设备直接输出的原始数据，不包含任何客户端计算
 */
data class NeuroSkyRawDataPoint(
    val timestamp: Long,                    // 时间戳（毫秒）
    val rawValues: List<Int>,               // 512Hz原始EEG数据
    val delta: Int,                         // Delta波功率值（μV²）
    val theta: Int,                         // Theta波功率值（μV²）
    val lowAlpha: Int,                      // 低Alpha波功率值（μV²）
    val highAlpha: Int,                     // 高Alpha波功率值（μV²）
    val lowBeta: Int,                       // 低Beta波功率值（μV²）
    val highBeta: Int,                      // 高Beta波功率值（μV²）
    val lowGamma: Int,                      // 低Gamma波功率值（μV²）
    val midGamma: Int,                      // 中Gamma波功率值（μV²）
    val attention: Int,                     // NeuroSky注意力指数 (0-100)
    val meditation: Int,                    // NeuroSky冥想指数 (0-100)
    val poorSignal: Int,                    // 信号质量 (0-200, 0最好)
    val blinkStrength: Int                  // 眨眼强度 (0-255)
)

/**
 * 生成一系列模拟数据
 */
fun generateSampleData(
    count: Int = 100,
    intervalMs: Long = 100L
): List<BrainWaveDataPoint> {
    val startTime = System.currentTimeMillis() - (count * intervalMs)
    return (0 until count).map { index ->
        BrainWaveDataGenerator.generateRandomDataPoint(startTime + (index * intervalMs))
    }
}